home *** CD-ROM | disk | FTP | other *** search
/ Young Minds / Young Minds Interactive CD-ROM.ISO / umoria / misc2.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-07-28  |  41.0 KB  |  1,982 lines

  1. #include <stdio.h>
  2. #include <sys/types.h>
  3.  
  4. #include "constants.h"
  5. #include "config.h"
  6. #include "types.h"
  7. #include "externs.h"
  8.  
  9. #ifdef USG
  10. #include <string.h>
  11. #else
  12. #include <strings.h>
  13. #endif
  14.  
  15. #ifdef sun   /* correct SUN stupidity in the stdio.h file */
  16. char *sprintf();
  17. #endif
  18.  
  19. #if defined(ultrix) || defined(sun) || defined(USG)
  20. int getuid();
  21. #else
  22. uid_t getuid();
  23. #endif
  24.  
  25. /* Places a particular trap at location y, x        -RAK-    */
  26. place_trap(y, x, typ, subval)
  27. int y, x, typ, subval;
  28. {
  29.   int cur_pos;
  30.   treasure_type cur_trap;
  31.  
  32.   if (typ == 1)
  33.     cur_trap = trap_lista[subval];
  34.   else
  35.     cur_trap = trap_listb[subval];
  36.   popt(&cur_pos);
  37.   cave[y][x].tptr  = cur_pos;
  38.   t_list[cur_pos] = cur_trap;
  39. }
  40.  
  41.  
  42. /* Places rubble at location y, x             -RAK-    */
  43. place_rubble(y, x)
  44. int y, x;
  45. {
  46.   int cur_pos;
  47.   register cave_type *cave_ptr;
  48.  
  49.   popt(&cur_pos);
  50.   cave_ptr = &cave[y][x];
  51.   cave_ptr->tptr = cur_pos;
  52.   cave_ptr->fopen = FALSE;
  53.   t_list[cur_pos] = rubble;
  54. }
  55.  
  56.  
  57. place_open_door(y, x)
  58. int y, x;
  59. {
  60.   int cur_pos;
  61.   register cave_type *cave_ptr;
  62.  
  63.   popt(&cur_pos);
  64.   cave_ptr = &cave[y][x];
  65.   cave_ptr->tptr = cur_pos;
  66.   t_list[cur_pos] = door_list[0];
  67.   cave_ptr->fval  = corr_floor3.ftval;
  68.   cave_ptr->fopen = TRUE;
  69. }
  70.  
  71.  
  72. place_broken_door(y, x)
  73. int y, x;
  74. {
  75.   int cur_pos;
  76.   register cave_type *cave_ptr;
  77.  
  78.   popt(&cur_pos);
  79.   cave_ptr = &cave[y][x];
  80.   cave_ptr->tptr = cur_pos;
  81.   t_list[cur_pos] = door_list[0];
  82.   cave_ptr->fval  = corr_floor3.ftval;
  83.   cave_ptr->fopen = TRUE;
  84.   t_list[cur_pos].p1 = 1;
  85. }
  86.  
  87.  
  88. place_closed_door(y, x)
  89. int y, x;
  90. {
  91.   int cur_pos;
  92.   register cave_type *cave_ptr;
  93.  
  94.   popt(&cur_pos);
  95.   cave_ptr = &cave[y][x];
  96.   cave_ptr->tptr = cur_pos;
  97.   t_list[cur_pos] = door_list[1];
  98.   cave_ptr->fval  = corr_floor3.ftval;
  99.   cave_ptr->fopen = FALSE;
  100. }
  101.  
  102.  
  103. place_locked_door(y, x)
  104. int y, x;
  105. {
  106.   int cur_pos;
  107.   register cave_type *cave_ptr;
  108.  
  109.   popt(&cur_pos);
  110.   cave_ptr = &cave[y][x];
  111.   cave_ptr->tptr = cur_pos;
  112.   t_list[cur_pos] = door_list[1];
  113.   cave_ptr->fval  = corr_floor3.ftval;
  114.   cave_ptr->fopen = FALSE;
  115.   t_list[cur_pos].p1 = randint(10) + 10;
  116. }
  117.  
  118.  
  119. place_stuck_door(y, x)
  120. int y, x;
  121. {
  122.   int cur_pos;
  123.   register cave_type *cave_ptr;
  124.  
  125.   popt(&cur_pos);
  126.   cave_ptr = &cave[y][x];
  127.   cave_ptr->tptr = cur_pos;
  128.   t_list[cur_pos] = door_list[1];
  129.   cave_ptr->fval  = corr_floor3.ftval;
  130.   cave_ptr->fopen = FALSE;
  131.   t_list[cur_pos].p1 = -randint(10) - 10;
  132. }
  133.  
  134.  
  135. place_secret_door(y, x)
  136. int y, x;
  137. {
  138.   int cur_pos;
  139.   register cave_type *cave_ptr;
  140.  
  141.   popt(&cur_pos);
  142.   cave_ptr = &cave[y][x];
  143.   cave_ptr->tptr = cur_pos;
  144.   t_list[cur_pos] = door_list[2];
  145.   cave_ptr->fval  = corr_floor4.ftval;
  146.   cave_ptr->fopen = FALSE;
  147. }
  148.  
  149.  
  150. place_door(y, x)
  151. int y, x;
  152. {
  153.   switch(randint(3))
  154.     {
  155.     case 1:
  156.       switch(randint(4))
  157.     {
  158.     case 1:
  159.       place_broken_door(y, x);
  160.       break;
  161.     default:
  162.       place_open_door(y, x);
  163.       break;
  164.     }
  165.       break;
  166.     case 2:
  167.       switch(randint(12))
  168.     {
  169.     case 1: case 2:
  170.       place_locked_door(y, x);
  171.       break;
  172.     case 3:
  173.       place_stuck_door(y, x);
  174.       break;
  175.     default:
  176.       place_closed_door(y, x);
  177.       break;
  178.     }
  179.     case 3:
  180.       place_secret_door(y, x);
  181.       break;
  182.     }
  183. }
  184.  
  185.  
  186. /* Place an up staircase at given y, x            -RAK-    */
  187. place_up_stairs(y, x)
  188. int y, x;
  189. {
  190.   int cur_pos;
  191.   register cave_type *cave_ptr;
  192.  
  193.   cave_ptr = &cave[y][x];
  194.   if (cave_ptr->tptr != 0)
  195.     {
  196.       pusht((int)cave_ptr->tptr);
  197.       cave_ptr->tptr = 0;
  198.       cave_ptr->fopen = TRUE;
  199.     }
  200.   popt(&cur_pos);
  201.   cave_ptr->tptr = cur_pos;
  202.   t_list[cur_pos] = up_stair;
  203. }
  204.  
  205.  
  206. /* Place a down staircase at given y, x            -RAK-    */
  207. place_down_stairs(y, x)
  208. int y, x;
  209. {
  210.   int cur_pos;
  211.   register cave_type *cave_ptr;
  212.  
  213.   cave_ptr = &cave[y][x];
  214.   if (cave_ptr->tptr != 0)
  215.     {
  216.       pusht((int)cave_ptr->tptr);
  217.       cave_ptr->tptr = 0;
  218.       cave_ptr->fopen = TRUE;
  219.     }
  220.   popt(&cur_pos);
  221.   cave_ptr->tptr = cur_pos;
  222.   t_list[cur_pos] = down_stair;
  223. }
  224.  
  225. /* Places a staircase 1==up, 2==down            -RAK-    */
  226. place_stairs(typ, num, walls)
  227. int typ, num, walls;
  228. {
  229.   register cave_type *cave_ptr;
  230.   int i, j;
  231.   register int y1, x1, y2, x2;
  232.   int flag;
  233.  
  234.   for (i = 0; i < num; i++)
  235.     {
  236.       flag = FALSE;
  237.       do
  238.     {
  239.       j = 0;
  240.       do
  241.         {
  242.           y1 = randint(cur_height - 12) - 1;
  243.           x1 = randint(cur_width  - 12) - 1;
  244.           y2 = y1 + 12;
  245.           x2 = x1 + 12;
  246.           do
  247.         {
  248.           do
  249.             {
  250.               cave_ptr = &cave[y1][x1];
  251.               if ((cave_ptr->fval == 1) || (cave_ptr->fval == 2) ||
  252.               (cave_ptr->fval == 4))
  253.             if (cave_ptr->tptr == 0)
  254.               if (next_to4(y1, x1, 10, 11, 12) >= walls)
  255.                 {
  256.                   flag = TRUE;
  257.                   switch(typ)
  258.                 {
  259.                 case 1:
  260.                   place_up_stairs(y1, x1);
  261.                   break;
  262.                 case 2:
  263.                   place_down_stairs(y1, x1);
  264.                   break;
  265.                 }
  266.                 }
  267.               x1++;
  268.             }
  269.           while ((x1 != x2) && (!flag));
  270.           x1 = x2 - 12;
  271.           y1++;
  272.         }
  273.           while ((y1 != y2) && (!flag));
  274.           j++;
  275.         }
  276.       while ((!flag) && (j <= 30));
  277.       walls--;
  278.     }
  279.       while (!flag);
  280.     }
  281. }
  282.  
  283.  
  284. /* Places a treasure (Gold or Gems) at given row, column -RAK-    */
  285. place_gold(y, x)
  286. int y, x;
  287. {
  288.   int cur_pos;
  289.   register int i;
  290.   register treasure_type *t_ptr;
  291.  
  292.   popt(&cur_pos);
  293.   i = ((randint(dun_level+2)+2)/2.0) - 1;
  294.   if (randint(OBJ_GREAT) == 1)
  295.     i += randint(dun_level+1);
  296.   if (i >= MAX_GOLD)
  297.     i = MAX_GOLD - 1;
  298.   cave[y][x].tptr = cur_pos;
  299.   t_list[cur_pos] = gold_list[i];
  300.   t_ptr = &t_list[cur_pos];
  301.   t_ptr->cost += randint(8*t_ptr->cost);
  302. }
  303.  
  304.  
  305. /* Returns the array number of a random object        -RAK-    */
  306. int get_obj_num(level)
  307. int level;
  308. {
  309.   register int i;
  310.  
  311.   if (level > MAX_OBJ_LEVEL)
  312.     level = MAX_OBJ_LEVEL;
  313.   if (randint(OBJ_GREAT) == 1)
  314.     level = MAX_OBJ_LEVEL;
  315.   if (level == 0)
  316.     i = randint(t_level[0]) - 1;
  317.   else
  318.     i = randint(t_level[level]) - 1;
  319.   return(i);
  320. }
  321.  
  322.  
  323. /* Places an object at given row, column co-ordinate    -RAK-    */
  324. place_object(y, x)
  325. int y, x;
  326. {
  327.   int cur_pos;
  328.   int tmp;
  329.   treasure_type tr_tmp;;
  330.  
  331.   popt(&cur_pos);
  332.   cave[y][x].tptr = cur_pos;
  333.   /* split this line up to avoid a reported compiler bug */
  334.   tmp = get_obj_num(dun_level);
  335.   tr_tmp = object_list[tmp];
  336.   t_list[cur_pos] = tr_tmp;
  337.   magic_treasure(cur_pos, dun_level);
  338. }
  339.  
  340.  
  341. /* Allocates an object for tunnels and rooms        -RAK-    */
  342. alloc_object(alloc_set, typ, num)
  343. int (*alloc_set)();
  344. int typ, num;
  345. {
  346.   register int i, j, k;
  347.  
  348.   for (k = 0; k < num; k++)
  349.     {
  350.       do
  351.     {
  352.       i = randint(cur_height) - 1;
  353.       j = randint(cur_width) - 1;
  354.     }
  355.       while ((!(*alloc_set)(cave[i][j].fval)) ||
  356.          (cave[i][j].tptr != 0));
  357.       switch(typ)
  358.     {
  359.     case 1:
  360.       place_trap(i, j, 1, randint(MAX_TRAPA)-1);
  361.       break;
  362.     case 2:
  363.       place_trap(i, j, 2, randint(MAX_TRAPB)-1);
  364.       break;
  365.     case 3:
  366.       place_rubble(i, j);
  367.       break;
  368.     case 4:
  369.       place_gold(i, j);
  370.       break;
  371.     case 5:
  372.       place_object(i, j);
  373.       break;
  374.     }
  375.     }
  376. }
  377.  
  378.  
  379. /* Creates objects nearby the coordinates given        -RAK-    */
  380. random_object(y, x, num)
  381. int y, x, num;
  382. {
  383.   register int i, j, k;
  384.   register cave_type *cave_ptr;
  385.  
  386.   do
  387.     {
  388.       i = 0;
  389.       do
  390.     {
  391.       j = y - 3 + randint(5);
  392.       k = x - 4 + randint(7);
  393.       cave_ptr = &cave[j][k];
  394.       if ((cave_ptr->fval <= 7) && (cave_ptr->fval >= 1))
  395.         if (cave_ptr->tptr == 0)
  396.           {
  397.         if (randint(100) < 75)
  398.           place_object(j, k);
  399.         else
  400.           place_gold(j, k);
  401.         i = 9;
  402.           }
  403.       i++;
  404.     }
  405.       while(i <= 10);
  406.       num--;
  407.     }
  408.   while (num != 0);
  409. }
  410.  
  411.  
  412. /* Converts stat num into string             -RAK-    */
  413. cnv_stat(stat, out_val)
  414. byteint stat;
  415. char *out_val;
  416. {
  417.   vtype tmp_str;
  418.   register int part1, part2;
  419.  
  420.   if (stat > 18)
  421.     {
  422.       part1 = 18;
  423.       part2 = stat - 18;
  424.       if (part2 == 100)
  425.     (void) strcpy(tmp_str, "18/100");
  426.       else if (part2 < 10)
  427.     (void) sprintf(tmp_str, " %2d/0%d", part1, part2);
  428.       else
  429.     (void) sprintf(tmp_str, " %2d/%2d", part1, part2);
  430.     }
  431.   else
  432.     (void) sprintf(tmp_str, "%6d", stat);
  433.   if (strlen(tmp_str) < 6)
  434.     (void) strcpy(tmp_str, pad(tmp_str, " ", 6));
  435.   (void) strcpy(out_val, tmp_str);
  436. }
  437.  
  438.  
  439. /* Print character stat in given row, column        -RAK-    */
  440. prt_stat(stat_name, stat, row, column)
  441. vtype stat_name;
  442. byteint stat;
  443. int row, column;
  444. {
  445.   stat_type out_val1;
  446.   vtype out_val2;
  447.  
  448.   cnv_stat(stat, out_val1);
  449.   (void) strcpy(out_val2, stat_name);
  450.   (void) strcat(out_val2, out_val1);
  451.   put_buffer(out_val2, row, column);
  452. }
  453.  
  454.  
  455. /* Print character info in given row, column        -RAK-    */
  456. /* the longest title is 13 characters, so only pad to 13 */
  457. prt_field(info, row, column)
  458. vtype info;
  459. int row, column;
  460. {
  461.   put_buffer(pad(info, " ", 13), row, column);
  462. }
  463.  
  464.  
  465. /* Print number with header at given row, column     -RAK-    */
  466. prt_num(header, num, row, column)
  467. vtype header;
  468. int num, row, column;
  469. {
  470.   vtype out_val;
  471.  
  472.   (void) sprintf(out_val, "%s%6d", header, num);
  473.   put_buffer(out_val, row, column);
  474. }
  475.  
  476.  
  477. /* Adjustment for wisdom                 -JWT-    */
  478. int wis_adj()
  479. {
  480.   if (py.stats.cwis > 117)
  481.     return(7);
  482.   else if (py.stats.cwis > 107)
  483.     return(6);
  484.   else if (py.stats.cwis > 87)
  485.     return(5);
  486.   else if (py.stats.cwis > 67)
  487.     return(4);
  488.   else if (py.stats.cwis > 17)
  489.     return(3);
  490.   else if (py.stats.cwis > 14)
  491.     return(2);
  492.   else if (py.stats.cwis > 7)
  493.     return(1);
  494.   else
  495.     return(0);
  496. }
  497.  
  498. /* adjustment for intelligence                -JWT-    */
  499. int int_adj()
  500. {
  501.   if (py.stats.cint > 117)
  502.     return(7);
  503.   else if (py.stats.cint > 107)
  504.     return(6);
  505.   else if (py.stats.cint > 87)
  506.     return(5);
  507.   else if (py.stats.cint > 67)
  508.     return(4);
  509.   else if (py.stats.cint > 17)
  510.     return(3);
  511.   else if (py.stats.cint > 14)
  512.     return(2);
  513.   else if (py.stats.cint > 7)
  514.     return(1);
  515.   else
  516.     return(0);
  517. }
  518.  
  519.  
  520. /* Adjustment for charisma                -RAK-    */
  521. /* Percent decrease or increase in price of goods                */
  522. double chr_adj()
  523. {
  524.   if (py.stats.cchr > 117)
  525.     return(-0.10);
  526.   else if (py.stats.cchr > 107)
  527.     return(-0.08);
  528.   else if (py.stats.cchr > 87)
  529.     return(-0.06);
  530.   else if (py.stats.cchr > 67)
  531.     return(-0.04);
  532.   else if (py.stats.cchr > 18)
  533.     return(-0.02);
  534.   else
  535.     switch(py.stats.cchr)
  536.       {
  537.       case 18:  return(0.00);
  538.       case 17:  return(0.01);
  539.       case 16:  return(0.02);
  540.       case 15:  return(0.03);
  541.       case 14:  return(0.04);
  542.       case 13:  return(0.06);
  543.       case 12:  return(0.08);
  544.       case 11:  return(0.10);
  545.       case 10:  return(0.12);
  546.       case 9:  return(0.14);
  547.       case 8:  return(0.16);
  548.       case 7:  return(0.18);
  549.       case 6:  return(0.20);
  550.       case 5:  return(0.22);
  551.       case 4:  return(0.24);
  552.       case 3:  return(0.25);
  553.       default: return(0.00);     /* Error trap    */
  554.       }
  555. }
  556.  
  557.  
  558. /* Returns a character's adjustment to hit points        -JWT-   */
  559. int con_adj()
  560. {
  561.   if (py.stats.ccon == 3)
  562.     return(-4);
  563.   else if (py.stats.ccon == 4)
  564.     return(-3);
  565.   else if (py.stats.ccon == 5)
  566.     return(-2);
  567.   else if (py.stats.ccon == 6)
  568.     return(-1);
  569.   else if (py.stats.ccon < 17)
  570.     return(0);
  571.   else if (py.stats.ccon ==  17)
  572.     return(1);
  573.   else if (py.stats.ccon <  94)
  574.     return(2);
  575.   else if (py.stats.ccon < 117)
  576.     return(3);
  577.   else
  578.     return(4);
  579. }
  580.  
  581.  
  582. /* Calculates hit points for each level that is gained.    -RAK-    */
  583. int get_hitdie()
  584. {
  585.   register int hitpoints;
  586.  
  587.   hitpoints = randint((int)py.misc.hitdie) + con_adj();
  588.   /* always give 'em at least one point */
  589.   if (hitpoints < 1)
  590.     hitpoints = 1;
  591.   return(hitpoints);
  592. }
  593.  
  594.  
  595. /* Prints title of character                -RAK-    */
  596. prt_title()
  597. {
  598.   prt_field(py.misc.title, 4, stat_column);
  599. }
  600.  
  601.  
  602. /* Prints strength                    -RAK-    */
  603. prt_strength()
  604. {
  605.   prt_stat("\0", py.stats.cstr, 6, stat_column+6);
  606. }
  607.  
  608.  
  609. /* Prints intelligence                    -RAK-    */
  610. prt_intelligence()
  611. {
  612.   prt_stat("\0", py.stats.cint, 7, stat_column+6);
  613. }
  614.  
  615.  
  616. /* Prints wisdom                     -RAK-    */
  617. prt_wisdom()
  618. {
  619.   prt_stat("\0", py.stats.cwis, 8, stat_column+6);
  620. }
  621.  
  622.  
  623. /* Prints dexterity                    -RAK-    */
  624. prt_dexterity()
  625. {
  626.   prt_stat("\0", py.stats.cdex, 9, stat_column+6);
  627. }
  628.  
  629.  
  630. /* Prints constitution                    -RAK-    */
  631. prt_constitution()
  632. {
  633.   prt_stat("\0", py.stats.ccon, 10, stat_column+6);
  634. }
  635.  
  636.  
  637. /* Prints charisma                    -RAK-    */
  638. prt_charisma()
  639. {
  640.   prt_stat("\0", py.stats.cchr, 11, stat_column+6);
  641. }
  642.  
  643.  
  644. /* Prints level                        -RAK-    */
  645. prt_level()
  646. {
  647.   prt_num("\0", (int)py.misc.lev, 13, stat_column+6);
  648. }
  649.  
  650.  
  651. /* Prints players current mana points (a real number...) -RAK-    */
  652. prt_cmana()
  653. {
  654.   prt_num("\0", (int)(py.misc.cmana), 15, stat_column+6);
  655. }
  656.  
  657.  
  658. /* Prints Max hit points                 -RAK-    */
  659. prt_mhp()
  660. {
  661.   prt_num("\0", py.misc.mhp, 16, stat_column+6);
  662. }
  663.  
  664.  
  665. /* Prints players current hit points (a real number...)    -RAK-    */
  666. prt_chp()
  667. {
  668.   prt_num("\0", (int)(py.misc.chp), 17, stat_column+6);
  669. }
  670.  
  671.  
  672. /* prints current AC                    -RAK-    */
  673. prt_pac()
  674. {
  675.   prt_num("\0", py.misc.dis_ac, 19, stat_column+6);
  676. }
  677.  
  678.  
  679. /* Prints current gold                    -RAK-    */
  680. prt_gold()
  681. {
  682.   prt_num("\0", py.misc.au, 20, stat_column+6);
  683. }
  684.  
  685.  
  686. /* Prints depth in stat area                -RAK-    */
  687. prt_depth()
  688. {
  689.   vtype depths;
  690.   register int depth;
  691.  
  692.   depth = dun_level*50;
  693.   if (depth == 0)
  694.     (void) strcpy(depths, "Town level");
  695.   else
  696.     (void) sprintf(depths, "Depth: %d (feet)", depth);
  697.   prt(depths, 23, 60);
  698. }
  699.  
  700.  
  701. /* Prints status of hunger                -RAK-    */
  702. prt_hunger()
  703. {
  704.   if (0x000002 & py.flags.status)
  705.     put_buffer("Weak    ", 23, 0);
  706.   else if (0x000001 & py.flags.status)
  707.     put_buffer("Hungry  ", 23, 0);
  708.   else
  709.     put_buffer("        ", 23, 0);
  710. }
  711.  
  712.  
  713. /* Prints Blind status                    -RAK-    */
  714. prt_blind()
  715. {
  716.   if (0x000004 & py.flags.status)
  717.     put_buffer("Blind  ", 23, 8);
  718.   else
  719.     put_buffer("       ", 23, 8);
  720. }
  721.  
  722.  
  723. /* Prints Confusion status                -RAK-    */
  724. prt_confused()
  725. {
  726.   if (0x000008 & py.flags.status)
  727.     put_buffer("Confused  ", 23, 15);
  728.   else
  729.     put_buffer("          ", 23, 15);
  730. }
  731.  
  732.  
  733. /* Prints Fear status                    -RAK-    */
  734. prt_afraid()
  735. {
  736.   if (0x000010 & py.flags.status)
  737.     put_buffer("Afraid  ", 23, 25);
  738.   else
  739.     put_buffer("        ", 23, 25);
  740. }
  741.  
  742.  
  743. /* Prints Poisoned status                -RAK-    */
  744. prt_poisoned()
  745. {
  746.   if (0x000020 & py.flags.status)
  747.     put_buffer("Poisoned  ", 23, 33);
  748.   else
  749.     put_buffer("          ", 23, 33);
  750. }
  751.  
  752.  
  753. /* Prints Searching status                -RAK-    */
  754. prt_search()
  755. {
  756.   if (0x000100 & py.flags.status)
  757.     put_buffer("Searching  ", 23, 43);
  758.   else
  759.     put_buffer("           ", 23, 43);
  760. }
  761.  
  762.  
  763. /* Prints Resting status                 -RAK-    */
  764. prt_rest()
  765. {
  766.   if (0x000200 & py.flags.status)
  767.     put_buffer("Resting    ", 23, 43);
  768.   else
  769.     put_buffer("           ", 23, 43);
  770. }
  771.  
  772.  
  773. /* Prints winner status on display            -RAK-    */
  774. prt_winner()
  775. {
  776.   put_buffer("*Winner*", 22, 0);
  777. }
  778.  
  779.  
  780. /* Increases a stat by one randomized level        -RAK-    */
  781. byteint in_statp(stat)
  782. register byteint stat;
  783. {
  784.   if (stat < 18)
  785.     stat++;
  786.   else if (stat < 88)
  787.     stat += randint(25);
  788.   else if (stat < 108)
  789.     stat += randint(10);
  790.   else
  791.     stat++;
  792.   if (stat > 118)
  793.     stat = 118;
  794.   return(stat);
  795. }
  796.  
  797.  
  798. /* Decreases a stat by one randomized level        -RAK-    */
  799. byteint de_statp(stat)
  800. register byteint stat;
  801. {
  802.   if (stat < 19)
  803.     stat--;
  804.   else if (stat < 109)
  805.     {
  806.       stat += -randint(10) - 5;
  807.       if (stat < 18)
  808.     stat = 18;
  809.      }
  810.   else
  811.     stat -= randint(3);
  812.   if (stat < 3)
  813.     stat = 3;
  814.   return(stat);
  815. }
  816.  
  817.  
  818. /* Increases a stat by one true level            -RAK-    */
  819. byteint in_statt(stat)
  820. register byteint stat;
  821. {
  822.   if (stat < 18)
  823.     stat++;
  824.   else
  825.     {
  826.       stat += 10;
  827.       if (stat > 118)
  828.     stat = 118;
  829.     }
  830.   return(stat);
  831. }
  832.  
  833.  
  834. /* Decreases a stat by true level            -RAK-    */
  835. byteint de_statt(stat)
  836. register byteint stat;
  837. {
  838.   if (stat > 27)
  839.     stat -= 10;
  840.   else if (stat > 18)
  841.     stat = 18;
  842.   else
  843.     {
  844.       stat--;
  845.       if (stat < 3)
  846.     stat = 3;
  847.     }
  848.   return(stat);
  849. }
  850.  
  851.  
  852. /* Returns a character's adjustment to hit.              -JWT-   */
  853. int tohit_adj()
  854. {
  855.   register int total;
  856.   register struct stats *s_ptr;
  857.  
  858.   s_ptr = &py.stats;
  859.   if      (s_ptr->cdex <   4)  total = -3;
  860.   else if (s_ptr->cdex <   6)  total = -2;
  861.   else if (s_ptr->cdex <   8)  total = -1;
  862.   else if (s_ptr->cdex <  16)  total =  0;
  863.   else if (s_ptr->cdex <  17)  total =  1;
  864.   else if (s_ptr->cdex <  18)  total =  2;
  865.   else if (s_ptr->cdex <  69)  total =  3;
  866.   else if (s_ptr->cdex < 118)  total =  4;
  867.   else                          total =  5;
  868.   if      (s_ptr->cstr <   4)  total -= 3;
  869.   else if (s_ptr->cstr <   5)  total -= 2;
  870.   else if (s_ptr->cstr <   7)  total -= 1;
  871.   else if (s_ptr->cstr <  18)  total -= 0;
  872.   else if (s_ptr->cstr <  94)  total += 1;
  873.   else if (s_ptr->cstr < 109)  total += 2;
  874.   else if (s_ptr->cstr < 117)  total += 3;
  875.   else                          total += 4;
  876.   return(total);
  877. }
  878.  
  879.  
  880. /* Returns a character's adjustment to armor class       -JWT-   */
  881. int toac_adj()
  882. {
  883.   register struct stats *s_ptr;
  884.  
  885.   s_ptr = &py.stats;
  886.   if      (s_ptr->cdex <   4)  return(-4);
  887.   else if (s_ptr->cdex ==  4)  return(-3);
  888.   else if (s_ptr->cdex ==  5)  return(-2);
  889.   else if (s_ptr->cdex ==  6)  return(-1);
  890.   else if (s_ptr->cdex <  15)  return( 0);
  891.   else if (s_ptr->cdex <  18)  return( 1);
  892.   else if (s_ptr->cdex <  59)  return( 2);
  893.   else if (s_ptr->cdex <  94)  return( 3);
  894.   else if (s_ptr->cdex < 117)  return( 4);
  895.   else                          return( 5);
  896. }
  897.  
  898.  
  899. /* Returns a character's adjustment to disarm            -RAK-   */
  900. int todis_adj()
  901. {
  902.   register struct stats *s_ptr;
  903.  
  904.   s_ptr = &py.stats;
  905.   if      (s_ptr->cdex ==  3)  return(-8);
  906.   else if (s_ptr->cdex ==  4)  return(-6);
  907.   else if (s_ptr->cdex ==  5)  return(-4);
  908.   else if (s_ptr->cdex ==  6)  return(-2);
  909.   else if (s_ptr->cdex ==  7)  return(-1);
  910.   else if (s_ptr->cdex <  13)  return( 0);
  911.   else if (s_ptr->cdex <  16)  return( 1);
  912.   else if (s_ptr->cdex <  18)  return( 2);
  913.   else if (s_ptr->cdex <  59)  return( 4);
  914.   else if (s_ptr->cdex <  94)  return( 5);
  915.   else if (s_ptr->cdex < 117)  return( 6);
  916.   else                          return( 8);
  917. }
  918.  
  919.  
  920. /* Returns a character's adjustment to damage            -JWT-   */
  921. int todam_adj()
  922. {
  923.   register struct stats *s_ptr;
  924.  
  925.   s_ptr = &py.stats;
  926.   if      (s_ptr->cstr <   4)  return(-2);
  927.   else if (s_ptr->cstr <   5)  return(-1);
  928.   else if (s_ptr->cstr <  16)  return( 0);
  929.   else if (s_ptr->cstr <  17)  return( 1);
  930.   else if (s_ptr->cstr <  18)  return( 2);
  931.   else if (s_ptr->cstr <  94)  return( 3);
  932.   else if (s_ptr->cstr < 109)  return( 4);
  933.   else if (s_ptr->cstr < 117)  return( 5);
  934.   else                          return( 6);
  935. }
  936.  
  937.  
  938. /* Prints character-screen info                -RAK-    */
  939. prt_stat_block()
  940. {
  941.   register int status;
  942.   register struct stats *s_ptr;
  943.   register struct misc *m_ptr;
  944.  
  945.   s_ptr = &py.stats;
  946.   m_ptr = &py.misc;
  947.   prt_field(m_ptr->race,                  2, stat_column);
  948.   prt_field(m_ptr->tclass,                3, stat_column);
  949.   prt_field(m_ptr->title,                 4, stat_column);
  950.   prt_stat("STR : ", s_ptr->cstr,         6, stat_column);
  951.   prt_stat("INT : ", s_ptr->cint,         7, stat_column);
  952.   prt_stat("WIS : ", s_ptr->cwis,         8, stat_column);
  953.   prt_stat("DEX : ", s_ptr->cdex,         9, stat_column);
  954.   prt_stat("CON : ", s_ptr->ccon,        10, stat_column);
  955.   prt_stat("CHR : ", s_ptr->cchr,        11, stat_column);
  956.   prt_num( "LEV : ", (int)m_ptr->lev,    13, stat_column);
  957.   prt_num( "EXP : ", m_ptr->exp,         14, stat_column);
  958.   prt_num( "MANA: ", (int)(m_ptr->cmana), 15, stat_column);
  959.   prt_num( "MHP : ", m_ptr->mhp,         16, stat_column);
  960.   prt_num( "CHP : ", (int)(m_ptr->chp),  17, stat_column);
  961.   prt_num( "AC  : ", m_ptr->dis_ac,      19, stat_column);
  962.   prt_num( "GOLD: ", m_ptr->au,          20, stat_column);
  963.   if (total_winner)  prt_winner();
  964.   status = py.flags.status;
  965.   if (0x000003 & status)
  966.     prt_hunger();
  967.   if (0x000004 & status)
  968.     prt_blind();
  969.   if (0x000008 & status)
  970.     prt_confused();
  971.   if (0x000010 & status)
  972.     prt_afraid();
  973.   if (0x000020 & status)
  974.     prt_poisoned();
  975.   if (0x000100 & status)
  976.     prt_search();
  977.   if (0x000200 & status)
  978.     prt_rest();
  979. }
  980.  
  981.  
  982. /* Draws entire screen                    -RAK-    */
  983. draw_cave()
  984. {
  985.   clear_screen(0, 0);
  986.   prt_stat_block();
  987.   prt_map();
  988.   prt_depth();
  989. }
  990.  
  991.  
  992. /* Prints the following information on the screen.    -JWT-    */
  993. put_character()
  994. {
  995.   char tmp_str[80];
  996.   register struct misc *m_ptr;
  997.  
  998.   m_ptr = &py.misc;
  999.   clear_screen(0, 0);
  1000.   prt(strcat(strcpy(tmp_str, "Name      : "), m_ptr->name), 2, 2);
  1001.   prt(strcat(strcpy(tmp_str, "Race      : "), m_ptr->race), 3, 2);
  1002.   prt(strcat(strcpy(tmp_str, "Sex       : "), m_ptr->sex), 4, 2);
  1003.   prt(strcat(strcpy(tmp_str, "Class     : "), m_ptr->tclass), 5, 2);
  1004. }
  1005.  
  1006.  
  1007. /* Prints the following information on the screen.    -JWT-    */
  1008. put_stats()
  1009. {
  1010.   register struct stats *s_ptr;
  1011.   register struct misc *m_ptr;
  1012.  
  1013.   m_ptr = &py.misc;
  1014.   s_ptr = &py.stats;
  1015.   prt_stat("STR : ", s_ptr->cstr, 2, 64);
  1016.   prt_stat("INT : ", s_ptr->cint, 3, 64);
  1017.   prt_stat("WIS : ", s_ptr->cwis, 4, 64);
  1018.   prt_stat("DEX : ", s_ptr->cdex, 5, 64);
  1019.   prt_stat("CON : ", s_ptr->ccon, 6, 64);
  1020.   prt_stat("CHR : ", s_ptr->cchr, 7, 64);
  1021.   prt_num("+ To Hit   : ", m_ptr->dis_th,  9, 3);
  1022.   prt_num("+ To Damage: ", m_ptr->dis_td, 10, 3);
  1023.   prt_num("+ To AC    : ", m_ptr->dis_tac, 11, 3);
  1024.   prt_num("  Total AC : ", m_ptr->dis_ac, 12, 3);
  1025. }
  1026.  
  1027.  
  1028. /* Returns a rating of x depending on y            -JWT-    */
  1029. char *likert(x, y)
  1030. int x, y;
  1031. {
  1032.   switch((x/y))
  1033.     {
  1034.       case -3: case -2: case -1: return("Very Bad");
  1035.       case 0: case 1:            return("Bad");
  1036.       case 2:                    return("Poor");
  1037.       case 3: case 4:            return("Fair");
  1038.       case  5:                   return("Good");
  1039.       case 6:                    return("Very Good");
  1040.       case 7: case 8:            return("Excellent");
  1041.       default:                   return("Superb");
  1042.       }
  1043. }
  1044.  
  1045.  
  1046. /* Prints age, height, weight, and SC            -JWT-    */
  1047. put_misc1()
  1048. {
  1049.   register struct misc *m_ptr;
  1050.  
  1051.   m_ptr = &py.misc;
  1052.   prt_num("Age          : ", (int)m_ptr->age, 2, 39);
  1053.   prt_num("Height       : ", (int)m_ptr->ht, 3, 39);
  1054.   prt_num("Weight       : ", (int)m_ptr->wt, 4, 39);
  1055.   prt_num("Social Class : ", (int)m_ptr->sc, 5, 39);
  1056. }
  1057.  
  1058.  
  1059. /* Prints the following information on the screen.    -JWT-    */
  1060. put_misc2()
  1061. {
  1062.   register struct misc *m_ptr;
  1063.  
  1064.   m_ptr = &py.misc;
  1065.   prt_num("Level      : ", (int)m_ptr->lev, 9, 30);
  1066.   prt_num("Experience : ", m_ptr->exp, 10, 30);
  1067.   prt_num("Gold       : ", m_ptr->au, 11, 30);
  1068.   prt_num("Max Hit Points : ", m_ptr->mhp, 9, 53);
  1069.   prt_num("Cur Hit Points : ", (int)m_ptr->chp, 10, 53);
  1070.   prt_num("Max Mana       : ", m_ptr->mana, 11, 53);
  1071.   prt_num("Cur Mana       : ", (int)m_ptr->cmana, 12, 53);
  1072. }
  1073.  
  1074.  
  1075. /* Prints ratings on certain abilities            -RAK-    */
  1076. put_misc3()
  1077. {
  1078.   int xbth, xbthb, xfos, xsrh, xstl, xdis, xsave, xdev;
  1079.   vtype xinfra;
  1080.   register struct misc *p_ptr;
  1081.   char tmp_str[80];
  1082.  
  1083.   clear_screen(13, 0);
  1084.   p_ptr = &py.misc;
  1085.   xbth  = p_ptr->bth + p_ptr->lev*BTH_LEV_ADJ + p_ptr->ptohit*BTH_PLUS_ADJ;
  1086.   xbthb = p_ptr->bthb + p_ptr->lev*BTH_LEV_ADJ + p_ptr->ptohit*BTH_PLUS_ADJ;
  1087.   /* this results in a range from 0 to 29 */
  1088.   xfos  = 40 - p_ptr->fos;
  1089.   if (xfos < 0)  xfos = 0;
  1090.   xsrh  = p_ptr->srh + int_adj();
  1091.   /* this results in a range from 0 to 9 */
  1092.   xstl  = p_ptr->stl + 1;
  1093.   xdis  = p_ptr->disarm + p_ptr->lev + 2*todis_adj() + int_adj();
  1094.   xsave = p_ptr->save + p_ptr->lev + wis_adj();
  1095.   xdev  = p_ptr->save + p_ptr->lev + int_adj();
  1096.   (void) sprintf(xinfra, "%d feet", py.flags.see_infra*10);
  1097.  
  1098.   prt("(Miscellaneous Abilities)", 15, 23);
  1099.   put_buffer(strcat(strcpy(tmp_str, "Fighting    : "),
  1100.             likert(xbth, 12)), 16, 1);
  1101.   put_buffer(strcat(strcpy(tmp_str, "Bows/Throw  : "),
  1102.             likert(xbthb, 12)), 17, 1);
  1103.   put_buffer(strcat(strcpy(tmp_str, "Saving Throw: "),
  1104.             likert(xsave, 6)), 18, 1);
  1105.   put_buffer(strcat(strcpy(tmp_str, "Stealth     : "),
  1106.             likert(xstl, 1)), 16, 26);
  1107.   put_buffer(strcat(strcpy(tmp_str, "Disarming   : "),
  1108.             likert(xdis, 8)), 17, 26);
  1109.   put_buffer(strcat(strcpy(tmp_str, "Magic Device: "),
  1110.             likert(xdev, 6)), 18, 26);
  1111.   put_buffer(strcat(strcpy(tmp_str, "Perception  : "),
  1112.             likert(xfos, 3)), 16, 51);
  1113.   put_buffer(strcat(strcpy(tmp_str, "Searching   : "),
  1114.             likert(xsrh, 6)), 17, 51);
  1115.   put_buffer(strcat(strcpy(tmp_str, "Infra-Vision: "), xinfra), 18, 51);
  1116. }
  1117.  
  1118.  
  1119. /* Used to display the character on the screen.        -RAK-    */
  1120. display_char()
  1121. {
  1122.   put_character();
  1123.   put_misc1();
  1124.   put_stats();
  1125.   put_misc2();
  1126.   put_misc3();
  1127. }
  1128.  
  1129.  
  1130. /* Gets a name for the character             -JWT-    */
  1131. get_name()
  1132. {
  1133.   prt("Enter your player's name  [press <RETURN> when finished]", 21, 2);
  1134.   (void) get_string(py.misc.name, 2, 14, 24);
  1135.   clear_screen(20, 0);
  1136. }
  1137.  
  1138.  
  1139. /* Chances the name of the character            -JWT-    */
  1140. change_name()
  1141. {
  1142.   char c;
  1143.   int flag;
  1144.  
  1145.   flag = FALSE;
  1146.   display_char();
  1147.   do
  1148.     {
  1149.       prt("<c>hange character name.     <ESCAPE> to continue.", 21, 2);
  1150.       inkey(&c);
  1151.       switch(c)
  1152.     {
  1153.     case 99:
  1154.       get_name();
  1155.       break;
  1156.     case 0: case 27:
  1157.       flag = TRUE;
  1158.       break;
  1159.     default:
  1160.       break;
  1161.     }
  1162.     }
  1163.   while (!flag);
  1164. }
  1165.  
  1166.  
  1167. /* Builds passwords                    -RAK-    */
  1168. bpswd()
  1169. {
  1170.   (void) strcpy(password1, PASSWD1);
  1171.   (void) strcpy(password2, PASSWD2);
  1172. }
  1173.  
  1174.  
  1175. /* Destroy an item in the inventory            -RAK-    */
  1176. inven_destroy(item_val)
  1177. int item_val;
  1178. {
  1179.   register int j;
  1180.   register treasure_type *i_ptr;
  1181.  
  1182.   inventory[INVEN_MAX] = inventory[item_val];
  1183.   i_ptr = &inventory[item_val];
  1184.   if ((i_ptr->number > 1) && (i_ptr->subval < 512))
  1185.     {
  1186.       i_ptr->number--;
  1187.       inven_weight -= i_ptr->weight;
  1188.       inventory[INVEN_MAX].number = 1;
  1189.     }
  1190.   else
  1191.     {
  1192.       inven_weight -= i_ptr->weight*i_ptr->number;
  1193.       for (j = item_val; j < inven_ctr-1; j++)
  1194.     inventory[j] = inventory[j+1];
  1195.       inventory[inven_ctr-1] = blank_treasure;
  1196.       inven_ctr--;
  1197.     }
  1198. }
  1199.  
  1200.  
  1201. /* Drops an item from inventory to given location    -RAK-    */
  1202. inven_drop(item_val, y, x)
  1203. int item_val, y, x;
  1204. {
  1205.   int i;
  1206.   register cave_type *cave_ptr;
  1207.  
  1208.   cave_ptr = &cave[y][x];
  1209.   if (cave_ptr->tptr != 0)
  1210.     pusht((int)cave_ptr->tptr);
  1211.   inven_destroy(item_val);
  1212.   popt(&i);
  1213.   t_list[i] = inventory[INVEN_MAX];
  1214.   cave_ptr->tptr = i;
  1215. }
  1216.  
  1217.  
  1218. /* Destroys a type of item on a given percent chance    -RAK-    */
  1219. int inven_damage(typ, perc)
  1220. int (*typ)();
  1221. register int perc;
  1222. {
  1223.   register int i, j;
  1224.  
  1225.   j = 0;
  1226.   for (i = 0; i < inven_ctr; i++)
  1227.     if ((*typ)(inventory[i].tval))
  1228.       if (randint(100) < perc)
  1229.     {
  1230.       inven_destroy(i);
  1231.       j++;
  1232.     }
  1233.   return(j);
  1234. }
  1235.  
  1236.  
  1237. /* Computes current weight limit             -RAK-    */
  1238. int weight_limit()
  1239. {
  1240.   register int weight_cap;
  1241.  
  1242.   weight_cap = py.stats.cstr * PLAYER_WEIGHT_CAP + py.misc.wt;
  1243.   if (weight_cap > 3000)  weight_cap = 3000;
  1244.   return(weight_cap);
  1245. }
  1246.  
  1247.  
  1248. /* Check inventory for too much weight            -RAK-    */
  1249. int inven_check_weight()
  1250. {
  1251.   register int item_wgt, max_weight;
  1252.   register int check_weight;
  1253.  
  1254.   check_weight = FALSE;
  1255.   max_weight = weight_limit();
  1256.   item_wgt = inventory[INVEN_MAX].number*inventory[INVEN_MAX].weight;
  1257.   /* Now, check to see if player can carry object  */
  1258.   if ((inven_weight + item_wgt) <= max_weight)
  1259.     check_weight = TRUE;   /* Can carry weight      */
  1260.   return(check_weight);
  1261. }
  1262.  
  1263.  
  1264. /* Check to see if he will be carrying too many objects    -RAK-    */
  1265. int inven_check_num()
  1266. {
  1267.   register int i;
  1268.   register int check_num;
  1269.  
  1270.   check_num = FALSE;
  1271.   if (inven_ctr < 22)
  1272.     check_num = TRUE;
  1273.   else if (inventory[INVEN_MAX].subval > 255)
  1274.     for (i = 0; i < inven_ctr; i++)
  1275.       if (inventory[i].tval == inventory[INVEN_MAX].tval)
  1276.     if (inventory[i].subval == inventory[INVEN_MAX].subval)
  1277.       check_num = TRUE;
  1278.   return(check_num);
  1279. }
  1280.  
  1281.  
  1282. /* Insert INVEN_MAX at given location    */
  1283. insert_inv(pos, wgt)
  1284. int pos, wgt;
  1285. {
  1286.   register int i;
  1287.  
  1288.   for (i = inven_ctr-1; i >= pos; i--)
  1289.     inventory[i+1] = inventory[i];
  1290.   inventory[pos] = inventory[INVEN_MAX];
  1291.   inven_ctr++;
  1292.   inven_weight += wgt;
  1293. }
  1294.  
  1295.  
  1296. /* Add the item in INVEN_MAX to players inventory.  Return the    */
  1297. /* item position for a description if needed...          -RAK-   */
  1298. inven_carry(item_val)
  1299. int *item_val;
  1300. {
  1301.   int item_num, wgt;
  1302.   register int typ, subt;
  1303.   int flag;
  1304.   register treasure_type *i_ptr;
  1305.  
  1306.   /* Now, check to see if player can carry object  */
  1307.   *item_val = 0;
  1308.   flag = FALSE;
  1309.   i_ptr = &inventory[INVEN_MAX];
  1310.   item_num = i_ptr->number;
  1311.   typ = i_ptr->tval;
  1312.   subt = i_ptr->subval;
  1313.   wgt = i_ptr->number*i_ptr->weight;
  1314.  
  1315.   do
  1316.     {
  1317.       i_ptr = &inventory[*item_val];
  1318.       if (typ == i_ptr->tval)
  1319.     {
  1320.       if (subt == i_ptr->subval)  /* Adds to other item    */
  1321.         if (subt > 255)
  1322.           {
  1323.         i_ptr->number += item_num;
  1324.         inven_weight += wgt;
  1325.         flag = TRUE;
  1326.           }
  1327.     }
  1328.       else if (typ > i_ptr->tval)
  1329.     {             /* Insert into list              */
  1330.       insert_inv(*item_val, wgt);
  1331.       flag = TRUE;
  1332.     }
  1333.       (*item_val)++;
  1334.     }
  1335.   while ((*item_val < inven_ctr) && (!flag));
  1336.   if (!flag)      /* Becomes last item in list     */
  1337.     {
  1338.       insert_inv(inven_ctr, wgt);
  1339.       *item_val = inven_ctr - 1;
  1340.     }
  1341.   else
  1342.     (*item_val)--;
  1343. }
  1344.  
  1345.  
  1346. /* Returns spell chance of failure for spell        -RAK-    */
  1347. spell_chance(spell)
  1348. register spl_rec *spell;
  1349. {
  1350.   register spell_type *s_ptr;
  1351.  
  1352.   s_ptr = &magic_spell[py.misc.pclass][spell->splnum];
  1353.   spell->splchn = s_ptr->sfail - 3*(py.misc.lev-s_ptr->slevel);
  1354.   if (class[py.misc.pclass].mspell)
  1355.     spell->splchn -= 3*(int_adj()-1);
  1356.   else
  1357.     spell->splchn -= 3*(wis_adj()-1);
  1358.   if (s_ptr->smana > py.misc.cmana)
  1359.     spell->splchn += 5*(s_ptr->smana-(int)py.misc.cmana);
  1360.   if (spell->splchn > 95)
  1361.     spell->splchn = 95;
  1362.   else if (spell->splchn < 5)
  1363.     spell->splchn = 5;
  1364. }
  1365.  
  1366.  
  1367. /* Print list of spells                    -RAK-    */
  1368. print_new_spells(spell, num, redraw)
  1369. spl_type spell;
  1370. register int num;
  1371. int *redraw;
  1372. {
  1373.   register int i;
  1374.   vtype out_val;
  1375.   register spell_type *s_ptr;
  1376.  
  1377.   *redraw = TRUE;
  1378.   clear_screen(1, 0);
  1379.   prt("   Name                          Level  Mana  %Failure", 1, 0);
  1380.   for (i = 0; i < num; i++)
  1381.     {
  1382.       s_ptr = &magic_spell[py.misc.pclass][spell[i].splnum];
  1383.       spell_chance(&spell[i]);
  1384.       (void) sprintf(out_val, "%c) %s%d    %d      %d", 97+i,
  1385.           pad(s_ptr->sname, " ", 30),
  1386.           s_ptr->slevel, s_ptr->smana, spell[i].splchn);
  1387.       prt(out_val, 2+i, 0);
  1388.     }
  1389. }
  1390.  
  1391.  
  1392. /* Returns spell pointer                 -RAK-    */
  1393. int get_spell(spell, num, sn, sc, prompt, redraw)
  1394. spl_type spell;
  1395. register int num;
  1396. register int *sn, *sc;
  1397. vtype prompt;
  1398. int *redraw;
  1399. {
  1400.   int flag;
  1401.   char choice;
  1402.   vtype out_val1;
  1403.  
  1404.   *sn = -1;
  1405.   flag = TRUE;
  1406.   (void) sprintf(out_val1, "(Spells a-%c, *==List, <ESCAPE>=exit) %s",
  1407.       num+96, prompt);
  1408.   prt(out_val1, 0, 0);
  1409.   while (((*sn < 0) || (*sn >= num)) && (flag))
  1410.     {
  1411.       inkey(&choice);
  1412.       *sn = (choice);
  1413.       switch(*sn)
  1414.     {
  1415.     case 0: case 27:
  1416.       flag = FALSE;
  1417.       reset_flag = TRUE;
  1418.       break;
  1419.     case 42:
  1420.       print_new_spells(spell, num, redraw);
  1421.           break;
  1422.     default:
  1423.       *sn -= 97;
  1424.       break;
  1425.     }
  1426.     }
  1427.   erase_line(MSG_LINE, 0);
  1428.   msg_flag = FALSE;
  1429.   if (flag)
  1430.     {
  1431.       spell_chance(&spell[*sn]);
  1432.       *sc = spell[*sn].splchn;
  1433.       *sn = spell[*sn].splnum;
  1434.     }
  1435.   return(flag);
  1436. }
  1437.  
  1438.  
  1439. /* Learn some magic spells (Mage)            -RAK-    */
  1440. int learn_spell(redraw)
  1441. int *redraw;
  1442. {
  1443.   unsigned int j;
  1444.   register int i, k, new_spells;
  1445.   int sn, sc;
  1446.   unsigned int spell_flag;
  1447.   spl_type spell;
  1448.   int learn;
  1449.   register spell_type *s_ptr;
  1450.  
  1451.   learn = FALSE;
  1452.   switch(int_adj())
  1453.     {
  1454.     case 0: new_spells = 0; break;
  1455.     case 1: new_spells = 1; break;
  1456.     case 2: new_spells = 1; break;
  1457.     case 3: new_spells = 1; break;
  1458.     case 4: new_spells = randint(2); break;
  1459.     case 5: new_spells = randint(2); break;
  1460.     case 6: new_spells = randint(3); break;
  1461.     case 7: new_spells = randint(2)+1; break;
  1462.     default: new_spells = 0; break;
  1463.     }
  1464.   i = 0;
  1465.   spell_flag = 0;
  1466.   do
  1467.     {
  1468.       if (inventory[i].tval == 90)
  1469.     spell_flag |= inventory[i].flags;
  1470.       i++;
  1471.     }
  1472.   while (i < inven_ctr);
  1473.   while ((new_spells > 0) && (spell_flag != 0))
  1474.     {
  1475.       i = 0;
  1476.       j = spell_flag;
  1477.       do
  1478.     {
  1479.       k = bit_pos(&j);
  1480.       s_ptr = &magic_spell[py.misc.pclass][k];
  1481.       if (s_ptr->slevel <= py.misc.lev)
  1482.         if (!s_ptr->learned)
  1483.           {
  1484.         spell[i].splnum = k;
  1485.         i++;
  1486.           }
  1487.     }
  1488.       while(j != 0);
  1489.       if (i > 0)
  1490.     {
  1491.       print_new_spells(spell, i, redraw);
  1492.       if (get_spell(spell, i, &sn, &sc, "Learn which spell?", redraw))
  1493.         {
  1494.           magic_spell[py.misc.pclass][sn].learned = TRUE;
  1495.           learn = TRUE;
  1496.           new_spells--;
  1497.           if (py.misc.mana == 0)
  1498.         {
  1499.           py.misc.mana  = 1;
  1500.           py.misc.cmana = 1.0;
  1501.         }
  1502.         }
  1503.       /* else do nothing if get_spell fails */
  1504.     }
  1505.       else
  1506.     new_spells = 0;
  1507.     }
  1508.   return(learn);
  1509. }
  1510.  
  1511.  
  1512. /* Learn some prayers (Priest)                -RAK-    */
  1513. int learn_prayer()
  1514. {
  1515.   register int i, j, k, l;
  1516.   int new_spell;
  1517.   int test_array[32];
  1518.   unsigned int spell_flag;
  1519.   int learn;
  1520.   register spell_type *s_ptr;
  1521.  
  1522.   i = 0;
  1523.   spell_flag = 0;
  1524.   do
  1525.     {
  1526.       if (inventory[i].tval == 91)
  1527.     spell_flag |= inventory[i].flags;
  1528.       i++;
  1529.     }
  1530.   while(i < inven_ctr);
  1531.   i = 0;
  1532.   while (spell_flag != 0)
  1533.     {
  1534.       j = bit_pos(&spell_flag);
  1535.       s_ptr = &magic_spell[py.misc.pclass][j];
  1536.       if (s_ptr->slevel <= py.misc.lev)
  1537.     if (!s_ptr->learned)
  1538.       {
  1539.         test_array[i] = j;
  1540.         i++;
  1541.       }
  1542.     }
  1543.   switch(wis_adj())
  1544.     {
  1545.     case 0: j = 0; break;
  1546.     case 1: j = 1; break;
  1547.     case 2: j = 1; break;
  1548.     case 3: j = 1; break;
  1549.     case 4: j = randint(2); break;
  1550.     case 5: j = randint(2); break;
  1551.     case 6: j = randint(3); break;
  1552.     case 7: j = randint(2)+1; break;
  1553.     }
  1554.   new_spell = 0;
  1555.   while ((i > 0) && (j > 0))
  1556.     {
  1557.       k = randint(i) - 1;
  1558.       magic_spell[py.misc.pclass][test_array[k]].learned = TRUE;
  1559.       new_spell++;
  1560.       for (l = k; l <= i-1; l++)
  1561.     test_array[l] = test_array[l+1];
  1562.       i--;       /* One less spell to learn       */
  1563.       j--;       /* Learned one                   */
  1564.     }
  1565.   if (new_spell > 0)
  1566.     {
  1567.       if (new_spell > 1)
  1568.     msg_print("You learned new prayers!");
  1569.       else
  1570.     msg_print("You learned a new prayer!");
  1571.       /* make sure player see the message when game starts */
  1572.       if (py.misc.exp == 0)  msg_print(" ");
  1573.       if (py.misc.mana == 0)
  1574.     {
  1575.       py.misc.mana  = 1;
  1576.       py.misc.cmana = 1.0;
  1577.     }
  1578.       learn = TRUE;
  1579.     }
  1580.   else
  1581.     learn = FALSE;
  1582.   return(learn);
  1583. }
  1584.  
  1585.  
  1586. /* Gain some mana if you knows at least one spell    -RAK-    */
  1587. gain_mana(amount)
  1588. int amount;
  1589. {
  1590.   register int i, new_mana;
  1591.   register int knows_spell;
  1592.  
  1593.   knows_spell = FALSE;
  1594.   for (i = 0; i < 31; i++)
  1595.     if (magic_spell[py.misc.pclass][i].learned)
  1596.       knows_spell = TRUE;
  1597.   if (knows_spell)
  1598.     {
  1599.       if (0x1 & py.misc.lev)
  1600.     switch(amount)
  1601.       {
  1602.       case 0: new_mana = 0; break;
  1603.       case 1: new_mana = 1; break;
  1604.       case 2: new_mana = 1; break;
  1605.       case 3: new_mana = 1; break;
  1606.       case 4: new_mana = 2; break;
  1607.       case 5: new_mana = 2; break;
  1608.       case 6: new_mana = 3; break;
  1609.       case 7: new_mana = 4; break;
  1610.       default: new_mana = 0; break;
  1611.       }
  1612.       else
  1613.     switch(amount)
  1614.       {
  1615.       case 0: new_mana = 0; break;
  1616.       case 1: new_mana = 1; break;
  1617.       case 2: new_mana = 1; break;
  1618.       case 3: new_mana = 2; break;
  1619.       case 4: new_mana = 2; break;
  1620.       case 5: new_mana = 3; break;
  1621.       case 6: new_mana = 3; break;
  1622.       case 7: new_mana = 4; break;
  1623.       default: new_mana = 0; break;
  1624.       }
  1625.       py.misc.mana  += new_mana;
  1626.       py.misc.cmana += new_mana;
  1627.     }
  1628. }
  1629.  
  1630.  
  1631. /* Increases hit points and level            -RAK-    */
  1632. gain_level()
  1633. {
  1634.   int nhp, dif_exp, need_exp;
  1635.   int redraw;
  1636.   vtype out_val;
  1637.   register struct misc *p_ptr;
  1638.   register class_type *c_ptr;
  1639.  
  1640.   p_ptr = &py.misc;
  1641.   nhp = get_hitdie();
  1642.   p_ptr->mhp += nhp;
  1643.   p_ptr->chp += (double)nhp;
  1644.   p_ptr->lev++;
  1645.   need_exp = (player_exp[p_ptr->lev-1] * p_ptr->expfact);
  1646.   if (py.misc.exp > need_exp)
  1647.     {
  1648.       /* lose some of the 'extra' exp when gain a level */
  1649.       dif_exp = py.misc.exp - need_exp;
  1650.       py.misc.exp = need_exp + (dif_exp / 2);
  1651.     }
  1652.   (void) strcpy(p_ptr->title, player_title[p_ptr->pclass][p_ptr->lev-1]);
  1653.   (void) sprintf(out_val, "Welcome to level %d.", (int)p_ptr->lev);
  1654.   msg_print(out_val);
  1655.   /* make sure player sees message, before learn_spell erases it */
  1656.   msg_print(" ");
  1657.   msg_flag = FALSE;
  1658.   prt_mhp();
  1659.   prt_chp();
  1660.   prt_level();
  1661.   prt_title();
  1662.   c_ptr = &class[p_ptr->pclass];
  1663.   if (c_ptr->mspell)
  1664.     {
  1665.       redraw = FALSE;
  1666.       (void) learn_spell(&redraw);
  1667.       if (redraw)  draw_cave();
  1668.       gain_mana(int_adj());
  1669.       prt_cmana();
  1670.     }
  1671.   else if (c_ptr->pspell)
  1672.     {
  1673.       (void) learn_prayer();
  1674.       gain_mana(wis_adj());
  1675.       prt_cmana();
  1676.     }
  1677. }
  1678.  
  1679. /* Prints experience                    -RAK-    */
  1680. prt_experience()
  1681. {
  1682.   register struct misc *p_ptr;
  1683.  
  1684.   p_ptr = &py.misc;
  1685.   if (p_ptr->exp > player_max_exp)
  1686.     p_ptr->exp = player_max_exp;
  1687.   if (p_ptr->lev < MAX_PLAYER_LEVEL)
  1688.     {
  1689.       while ((player_exp[p_ptr->lev-1] * p_ptr->expfact) <= p_ptr->exp)
  1690.     gain_level();
  1691.       if (p_ptr->exp > p_ptr->max_exp)
  1692.     p_ptr->max_exp = p_ptr->exp;
  1693.     }
  1694.   prt_num("", py.misc.exp, 14, stat_column+6);
  1695. }
  1696.  
  1697.  
  1698. /* Inserts a string into a string                */
  1699. insert_str(object_str, mtc_str, insert)
  1700. char *object_str, *mtc_str, *insert;
  1701. {
  1702.   int obj_len;
  1703.   char *bound, *pc;
  1704.   register int i, mtc_len;
  1705.   register char *temp_obj, *temp_mtc;
  1706.   char out_val[80];
  1707.  
  1708.   mtc_len = strlen(mtc_str);
  1709.   obj_len = strlen(object_str);
  1710.   bound = object_str + obj_len - mtc_len;
  1711.   for (pc = object_str; pc <= bound; pc++)
  1712.     {
  1713.       temp_obj = pc;
  1714.       temp_mtc = mtc_str;
  1715.       for (i = 0; i < mtc_len; i++)
  1716.     if (*temp_obj++ != *temp_mtc++)
  1717.       break;
  1718.       if (i == mtc_len)
  1719.     break;
  1720.     }
  1721.  
  1722.   if (pc <= bound)
  1723.     {
  1724.       (void) strncpy(out_val, object_str, (pc-object_str));
  1725.       out_val[(pc-object_str)] = '\0';
  1726.       (void) strcat(out_val, insert);
  1727.       (void) strcat(out_val, (char *)(pc+mtc_len));
  1728.       (void) strcpy(object_str, out_val);
  1729.     }
  1730. }
  1731.  
  1732.  
  1733. /* Inserts a number into a string                */
  1734. insert_num(object_str, mtc_str, number, show_sign)
  1735. char *object_str;
  1736. register char *mtc_str;
  1737. int number;
  1738. int show_sign;
  1739. {
  1740.   int pos, mlen;
  1741.   vtype str1, str2;
  1742.   register char *string, *tmp_str;
  1743.   int flag;
  1744.  
  1745.   flag = 1;
  1746.   tmp_str = object_str;
  1747.   do
  1748.     {
  1749.       string = index(tmp_str, mtc_str[0]);
  1750.       if (string == 0)
  1751.     flag = 0;
  1752.       else
  1753.     {
  1754.       flag = strncmp(string, mtc_str, strlen(mtc_str));
  1755.       if (flag)
  1756.         tmp_str = string+1;
  1757.     }
  1758.     }
  1759.   while (flag);
  1760.   if (string)
  1761.     pos = strlen(object_str) - strlen(string);
  1762.   else
  1763.     pos = -1;
  1764.   if (pos >= 0)
  1765.     {
  1766.       mlen = strlen(mtc_str);
  1767.       (void) strncpy(str1, object_str, pos);
  1768.       str1[pos] = '\0';
  1769.       (void) strcpy(str2, &object_str[pos+mlen]);
  1770.       if ((number >= 0) && (show_sign))
  1771.     (void) sprintf(object_str, "%s+%d%s", str1, number, str2);
  1772.       else
  1773.     (void) sprintf(object_str, "%s%d%s", str1, number, str2);
  1774.     }
  1775. }
  1776.  
  1777.  
  1778. /* Checks to see if user is a wizard            -RAK-    */
  1779. int check_pswd()
  1780. {
  1781.   register int i;
  1782.   char x;
  1783.   char tpw[12];
  1784.   register int check;
  1785.  
  1786.   check = FALSE;
  1787.   if (getuid() != UID)
  1788.     return(FALSE);
  1789.   i = 0;
  1790.   tpw[0] = '\0';
  1791.   prt("Password : ", 0, 0);
  1792.   do
  1793.     {
  1794.       inkey(&x);
  1795.       switch(x)
  1796.     {
  1797.     case 10:
  1798.     case 13:
  1799.       break;
  1800.     default:
  1801.       tpw[i] = x;
  1802.       i++;
  1803.       break;
  1804.     }
  1805.     }
  1806.   while ((i != 12) && (x != 13) && (x != 10));
  1807.   tpw[i] = '\0';
  1808.   if (!strcmp(tpw, password1))
  1809.     {
  1810.       wizard1 = TRUE;
  1811.       check = TRUE;
  1812.     }
  1813.   else if (!strcmp(tpw, password2))
  1814.     {
  1815.       wizard1 = TRUE;
  1816.       wizard2 = TRUE;
  1817.       check = TRUE;
  1818.     }
  1819.   msg_flag = FALSE;
  1820.   erase_line(MSG_LINE, 0);
  1821.   return(check);
  1822. }
  1823.  
  1824.  
  1825. /* Weapon weight VS strength and dexterity        -RAK-    */
  1826. int attack_blows(weight, wtohit)
  1827. int weight;
  1828. int *wtohit;
  1829. {
  1830.   register int adj_weight, blows;
  1831.   register struct stats *p_ptr;
  1832.  
  1833.   blows  = 1;
  1834.   *wtohit = 0;
  1835.   p_ptr = &py.stats;
  1836.   if ((p_ptr->cstr*15) < weight)
  1837.     *wtohit = p_ptr->cstr*15 - weight;
  1838.   else
  1839.     {
  1840.       if      (p_ptr->cdex <  10)  blows = 1;
  1841.       else if (p_ptr->cdex <  19)  blows = 2;
  1842.       else if (p_ptr->cdex <  68)  blows = 3;
  1843.       else if (p_ptr->cdex < 108)  blows = 4;
  1844.       else if (p_ptr->cdex < 118)  blows = 5;
  1845.       else                         blows = 6;
  1846.       adj_weight = ((p_ptr->cstr*10)/weight);
  1847.       if      (adj_weight < 2)  blows = 1;
  1848.       else if (adj_weight < 3)  blows = (blows/3.0) + 1;
  1849.       else if (adj_weight < 4)  blows = (blows/2.5) + 1;
  1850.       else if (adj_weight < 5)  blows = (blows/2.25) + 1;
  1851.       else if (adj_weight < 7)  blows = (blows/2.00) + 1;
  1852.       else if (adj_weight < 9)  blows = (blows/1.75) + 1;
  1853.       else                      blows = (blows/1.50) + 1;
  1854.     }
  1855.   return(blows);
  1856. }
  1857.  
  1858.  
  1859. /* Critical hits, Nasty way to die...            -RAK-    */
  1860. int critical_blow(weight, plus, dam)
  1861. register int weight, plus, dam;
  1862. {
  1863.   register int critical;
  1864.  
  1865.   critical = dam;
  1866.   /* Weight of weapon, plusses to hit, and character level all      */
  1867.   /* contribute to the chance of a critical                        */
  1868.   if (randint(5000) <= (int)(weight+5*plus+3*py.misc.lev))
  1869.     {
  1870.       weight += randint(650);
  1871.       if (weight < 400)
  1872.     {
  1873.       critical = 2*dam + 5;
  1874.       msg_print("It was a good hit! (x2 damage)");
  1875.     }
  1876.       else if (weight < 700)
  1877.     {
  1878.       critical = 3*dam + 10;
  1879.       msg_print("It was an excellent hit! (x3 damage)");
  1880.     }
  1881.       else if (weight < 900)
  1882.     {
  1883.       critical = 4*dam + 15;
  1884.       msg_print("It was a superb hit! (x4 damage)");
  1885.     }
  1886.       else
  1887.     {
  1888.       critical = 5*dam + 20;
  1889.       msg_print("It was a *GREAT* hit! (x5 damage)");
  1890.     }
  1891.     }
  1892.   return(critical);
  1893. }
  1894.  
  1895.  
  1896. /* Given direction "dir", returns new row, column location -RAK- */
  1897. int move(dir, y, x)
  1898. int dir;
  1899. register int *y, *x;
  1900. {
  1901.   register int new_row, new_col;
  1902.   int bool;
  1903.  
  1904.   switch(dir)
  1905.     {
  1906.     case 1:
  1907.       new_row = *y + 1;
  1908.       new_col = *x - 1;
  1909.       break;
  1910.     case 2:
  1911.       new_row = *y + 1;
  1912.       new_col = *x;
  1913.       break;
  1914.     case 3:
  1915.       new_row = *y + 1;
  1916.       new_col = *x + 1;
  1917.       break;
  1918.     case 4:
  1919.       new_row = *y;
  1920.       new_col = *x - 1;
  1921.       break;
  1922.     case 5:
  1923.       new_row = *y;
  1924.       new_col = *x;
  1925.       break;
  1926.     case 6:
  1927.       new_row = *y;
  1928.       new_col = *x + 1;
  1929.       break;
  1930.     case 7:
  1931.       new_row = *y - 1;
  1932.       new_col = *x - 1;
  1933.       break;
  1934.     case 8:
  1935.       new_row = *y - 1;
  1936.       new_col = *x;
  1937.       break;
  1938.     case 9:
  1939.       new_row = *y - 1;
  1940.       new_col = *x + 1;
  1941.       break;
  1942.     }
  1943.   bool = FALSE;
  1944.   if ((new_row >= 0) && (new_row < cur_height))
  1945.     if ((new_col >= 0) && (new_col < cur_width))
  1946.       {
  1947.     *y = new_row;
  1948.     *x = new_col;
  1949.     bool = TRUE;
  1950.       }
  1951.   return(bool);
  1952. }
  1953.  
  1954. /* Saving throws for player character...         -RAK-    */
  1955. int player_saves(adjust)
  1956. int adjust;
  1957. {
  1958.   if (randint(100) <= (py.misc.save + py.misc.lev + adjust))
  1959.     return(TRUE);
  1960.   else
  1961.     return(FALSE);
  1962. }
  1963.  
  1964.  
  1965. /* Init players with some belongings            -RAK-    */
  1966. char_inven_init()
  1967. {
  1968.   register int i, j;
  1969.   int dummy;
  1970.  
  1971.   /* this is needed for bash to work right, it can't hurt anyway */
  1972.   for (i = 0; i < INVEN_ARRAY_SIZE; i++)
  1973.     inventory[i] = blank_treasure;
  1974.  
  1975.   for (i = 0; i < 5; i++)
  1976.     {
  1977.       j = player_init[py.misc.pclass][i];
  1978.       inventory[INVEN_MAX] = inventory_init[j];
  1979.       inven_carry(&dummy);
  1980.     }
  1981. }
  1982.